//必须带done回调 执行完成调用
import { gp } from '@vui'
import merge from 'lodash/merge'
import isArray from 'lodash/isArray'
import trim from 'lodash/trim'
import { getModelByModelTree, processingConstant, getActionData } from '@ve/utils/utils'
import cloneDeep from 'lodash/cloneDeep'
import isEmpty from 'lodash/isEmpty'
import { translateTitle } from '@/utils/i18n'

export default function injectData({ vm, action, done, callbackData, additionalData }) {
  console.log('callbackData ============== ', callbackData)
  console.log('additionalData =============== ', additionalData)
  console.log('action ============ ', action)
  console.log('vm', vm)

  const modelIdList = action.extension.receiveObject.value && action.extension.receiveObject.value.source
  const modelTree = vm.$store.state.preview.pages[vm.$store.state.preview.nowPageId]

  const getcustomDatas = (dataObj) => {
    const dataList = action.extension.injectData.value
    dataList.forEach((item) => {
      // 做常量转化
      if (action.extension.injectData.constantTransformation) {
        dataObj[item.key] = processingConstant(vm, item.value)
      } else {
        dataObj[item.key] = item.value
      }
    })
  }

  // 数据处理函数
  const dataManipulation = (callbackDataObj) => {
    let returnData = {}
    // 根据获取数据路径筛选数据
    const getDataPath = action.extension.injectData.getDataPath || ''
    if (trim(getDataPath)) {
      if (getDataPath.indexOf('->') !== -1) {
        const fieldList = getDataPath.split('->')
        // window.cacheObj[b] = _callbackData
        fieldList.forEach((fieldItem) => {
          // 如果没有后续值则不继续往下取值
          if (callbackDataObj[trim(fieldItem)] === undefined) return
          callbackDataObj = callbackDataObj[trim(fieldItem)]
        })
      } else {
        callbackDataObj = callbackDataObj[trim(getDataPath)] || {}
      }
    }
    // console.log('callbackDataObj ----------------- ', callbackDataObj)
    const getDataKey = action.extension.injectData.getDataKey
    const injectDataKey = action.extension.injectData.injectDataKey || ''
    if (!trim(getDataKey)) {
      // 如果没有获取数据Key 则返回全量数据
      returnData = cloneDeep(callbackDataObj)
    } else {
      const getDataKeyList = getDataKey.split(',')
      if (!injectDataKey) {
        // 如果没有注入数据 key 则返回获取数据key
        getDataKeyList.map((item) => {
          item = trim(item)
          returnData[item] = callbackDataObj[item]
        })
      } else {
        // 如果有注入数据 key
        const injectDataKeyList = injectDataKey.split(',')
        getDataKeyList.map((item, index) => {
          item = trim(item)
          // 有注入数据 key 则用注入数据 key, 没有则用获取数据 key
          const dataKey = injectDataKeyList[index] || item
          returnData[dataKey] = callbackDataObj[item]
        })
      }
    }
    return returnData
  }

  modelIdList.forEach((modelId) => {
    let _model = getModelByModelTree(modelId, modelTree)

    let dataObj = {}
    if (_model) {
      // 组织数据
      // 如果有新版数据源配置 则优先使用新版数据源获取数据
      const dataSource = action.extension.injectData.dataSource
      const dataSourceAction = action.extension.injectData.dataSourceAction
      if (dataSource) {
        if (dataSource === 'custom') {
          // 自定义数据
          getcustomDatas(dataObj)
        } else {
          let callbackDataObj = null
          if (dataSource === 'event') {
            // 使用事件数据
            callbackDataObj = isArray(additionalData.data) ? additionalData.data[0] : additionalData.data
            if (!callbackDataObj) {
              callbackDataObj = additionalData.row
            }
          } else {
            // 使用动作数据
            let actionData = callbackData // 默认使用上一次动作数据
            if (dataSourceAction) {
              // 使用指定动作数据
              actionData = getActionData(vm, vm.info._id, dataSourceAction)
            }
            if (isArray(actionData)) {
              callbackDataObj = cloneDeep(actionData[0])
              // 如果有配置获取多值 则进行值拼接
              if (action.extension.injectData.getMoreValueKey) {
                const getDataKeyList = action.extension.injectData.getMoreValueKey.split(',')
                getDataKeyList.map((item) => {
                  item = trim(item)
                  callbackDataObj[item] = ''
                  actionData.forEach((dataItem) => {
                    if (!callbackDataObj[item]) {
                      callbackDataObj[item] = dataItem[item] || ''
                    } else {
                      callbackDataObj[item] = callbackDataObj[item] + `${action.extension.injectData.getMoreValueJoinSym}` + `${dataItem[item] || ''}`
                    }
                  })
                })
              }
            } else {
              callbackDataObj = actionData
            }
          }
          // 数据处理
          dataObj = dataManipulation(callbackDataObj, dataObj)
        }
      } else {
        // 旧版获取数据方法
        if (action.extension.injectData.useLastData) {
          // 如果选择为使用上次任务数据
          let callbackDataObj = null
          // 如果有表格项点击传过来的数据 则用传过来的数据 否则使用队列回调数据
          if (additionalData && !action.extension.injectData.notUseTableData) {
            callbackDataObj = isArray(additionalData.data) ? additionalData.data[0] : additionalData.data
            if (!callbackDataObj) {
              callbackDataObj = additionalData.row
            }
          } else {
            // callbackDataObj = isArray(callbackData) ? callbackData[0] : callbackData
            if (isArray(callbackData)) {
              callbackDataObj = cloneDeep(callbackData[0])
              // 如果有配置获取多值 则进行值拼接
              if (action.extension.injectData.getMoreValueKey) {
                const getDataKeyList = action.extension.injectData.getMoreValueKey.split(',')
                getDataKeyList.map((item) => {
                  item = trim(item)
                  callbackDataObj[item] = ''
                  callbackData.forEach((dataItem) => {
                    if (!callbackDataObj[item]) {
                      callbackDataObj[item] = dataItem[item] || ''
                    } else {
                      callbackDataObj[item] = callbackDataObj[item] + `${action.extension.injectData.getMoreValueJoinSym}` + `${dataItem[item] || ''}`
                    }
                  })
                })
              }
            } else {
              callbackDataObj = callbackData
            }
          }
          // 数据处理
          dataObj = dataManipulation(callbackDataObj, dataObj)
        } else {
          getcustomDatas(dataObj)
        }
      }

      console.log('用于注入的数据 ------------ ', dataObj)
      // 赋值数据
      if (_model.type === 1 || _model.type === 2) {
        // 如果组件为页面类型 则将数据注入到 requestData
        _model.data.requestData ? '' : (_model.data.requestData = {})
        merge(_model.data.requestData, dataObj)
      } else if (_model.type === 'uiUpload') {
        if (vm.vuiComponents[_model._id]) {
          vm.vuiComponents[_model._id]?.self?.$setUploadModel(dataObj)
        }
      } else if (_model.type === 'uiImage') {
        if (vm.vuiComponents[_model._id]) {
          vm.vuiComponents[_model._id]?.self?.$setUploadModel(dataObj)
        }
      } else {
        if (!isEmpty(vm.vuiComponents)) {
          for (let v in vm.vuiComponents) {
            if (vm.vuiComponents[v].self.info.type == 'uiPdaSelect') {
              let extension = vm.vuiComponents[v].self.info.extension
              let chaceItem = extension.optionConfig.value.find((vv) => {
                return vv[extension.valueField.value] == dataObj[extension.model.value]
              })
              if (!isEmpty(chaceItem)) {
                vm.vuiComponents[v].self.formDataModelLabel = chaceItem[extension.labelField.value]
              }
            }
          }
        }

        // 否则将数据注入到 formData
        if (!_model.data || !_model.data.formData) {
          _model.data = {}
          _model.data.formData = {}
        }
        // _model.data.formData ? '' : (_model.data.formData = {})

        if (isArray(dataObj) && _model.type !== 'uiPdaTable' && _model.type !== 'uiPdaSelect' && _model.type !== 'uiPdaPagination') {
          dataObj = dataObj[0]
        }
        merge(_model.data.formData, dataObj)
        if (_model.type === 'uiForm') {
          // 如果组件为 form 组件 则缓存一下当前 formData 以供重置表单使用
          // _model.data._formData = cloneDeep(_model.data.formData)
          merge(_model.data._formData, dataObj)
          // 触发改变了数据的表单项组件的值改变事件
          // 先取消触发值改变事件
          // const keyList = keys(dataObj)
          // const eachFunc = (obj) => {
          //   const modelVal = obj.extension?.model?.value
          //   // 查找组件的 model 值绑定在修改值对象中
          //   if (modelVal && includes(keyList, modelVal)) {
          //     // 触发组件的值改变事件
          //     if (vm.vuiComponents[obj._id]?.self?.formDataModel !== dataObj[modelVal]) {
          //       vm.vuiComponents[obj._id]?.self?.onChange()
          //     }
          //   }
          //   obj.pageModules &&
          //     obj.pageModules.forEach((item) => {
          //       eachFunc(item)
          //     })
          //   obj.list &&
          //     obj.list.forEach((item) => {
          //       eachFunc(item)
          //     })
          // }
          // eachFunc(_model)
        }
      }

      //  Nico操作表格数据注入
      if (_model.type === 'uiPdaTable') {
        _model.data.formData = cloneDeep(dataObj)
      }
      // Nico数据注入方式渲染下拉选
      if (_model.type === 'uiPdaSelect') {
        _model.extension.optionConfig.value = cloneDeep(Object.values(dataObj))
      }
      // Afun 数据注入方式渲染分页器
      if (_model.type === 'uiPdaPagination') {
        _model.data.formData = cloneDeep(Object.values(dataObj))
        console.log('_model_model_model', _model)
      }

      vm.$store.commit('preview/setPageData', modelTree)
      // 提交 dispatch 触发页面组件状态更新（ dataObj 为传递的数据对象，moduleObj 为目标组件对象
      // vm.$store.dispatch('pageModulesState/setPageModulesStateByObj', { dataObj: dataObj, moduleObj: _model })
      if (!(process.env.VUE_APP_BuildProjectType === 'mobile' || vm.$store.state.diy.settings.mode == 'mobile')) {
        vm.$store.dispatch('pageModulesState/setPageModulesStatesByObj', {
          pageId: vm.$store.getters['preview/getNowPageId'],
          pageState: { dataObj: dataObj, moduleObj: _model },
        })
      }
    } else {
      gp.$baseMessage(translateTitle('Ve.utils.没有找到组件') + 'injectData', 'warning')
    }
  })
  vm.$nextTick(() => {
    done(null, callbackData)
  })
}
